package com.fengmi.service.impl;

import cn.hutool.json.JSONUtil;
import com.fengmi.entity.MallGoodsSpec;
import com.fengmi.entity.MallGoodsSpecOptions;
import com.fengmi.entity.MallGoodsTemplate;
import com.fengmi.mapper.MallGoodsSpecMapper;
import com.fengmi.mapper.MallGoodsSpecOptionsMapper;
import com.fengmi.mapper.MallGoodsTemplateMapper;
import com.fengmi.service.MallGoodsSpecOptionsService;
import com.fengmi.vo.InfoResult;
import com.fengmi.vo.PageResult;
import com.fengmi.vo.SpecOptionsVO;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.*;
import java.util.stream.Collectors;

/**
 * Author: 施俊豪
 * Date: 2022/1/19 10:10
 * Note: MallGoodsSpecOptionsService实现类
 */
@Transactional
@Service
public class MallGoodsSpecOptionsServiceImpl implements MallGoodsSpecOptionsService {

    @Autowired(required = false)
    private MallGoodsSpecOptionsMapper mallGoodsSpecOptionsMapper;
    @Autowired(required = false)
    private MallGoodsSpecMapper mallGoodsSpecMapper;
    @Autowired(required = false)
    private MallGoodsTemplateMapper mallGoodsTemplateMapper;

    /**
     * @Note : 产品规格+规格选项 的 条件+分页查询
     * @Date : 2022-01-19 10:14:31
     * @Author : 清酒吖
    */
    @Override
    public PageResult<MallGoodsSpecOptions> findSpecAndOptions(MallGoodsSpecOptions options, String pageNum, String pageSize) {
        //分页查询
        PageHelper.startPage(Integer.parseInt(pageNum),Integer.parseInt(pageSize));
        //条件查询
        List<MallGoodsSpecOptions> goodsSpecList = mallGoodsSpecOptionsMapper.findGoodsSpec(options);
        //返回pageInfo结果
        PageInfo<MallGoodsSpecOptions> pageInfo = new PageInfo<>(goodsSpecList);
        //返回pageResult结果
        PageResult<MallGoodsSpecOptions> pageResult = new PageResult<>();
        pageResult.setTotal(pageInfo.getTotal());
        pageResult.setPages(pageInfo.getPages());
        pageResult.setPageList(pageInfo.getList());

        return pageResult;
    }

    /**
     * @Note : 添加商品规格和规格选项
     * @Date : 2022-01-21 09:29:16
     * @Author : 清酒吖
    */
    @Override
    public InfoResult addSpecAndOptions(MallGoodsSpec spec) {
        // 执行的添加成功次数
        int count = 0;

        //如果传入的参数为空,则返回错误信息
        if(spec == null){
            return new InfoResult(false,"参数错误","");
        }

        //如果传入的规格名称为空,则返回错误信息
        if(StringUtils.isEmpty(spec.getSpecName())){
            return new InfoResult(false,"参数错误","");
        }

        boolean flag = true;
        //如果传入的参数中，规格选项全为空,则不执行添加
        for (MallGoodsSpecOptions option : spec.getOptions()) {
            // 只要有个规格选项不为空,则继续往下执行添加
            if(!StringUtils.isEmpty(option.getOptionName())){
                flag = false;
            }
        }
        if(flag){
            return new InfoResult(false,"参数错误","");
        }

        //根据商品规格查询该规格是否存在
        MallGoodsSpec mallGoodsSpec = mallGoodsSpecMapper.findSpecByName(spec.getSpecName());
        // 如果该商品规格不存在,则先添加该商品规格
        if(mallGoodsSpec==null){
            Integer InsertSpecRow = mallGoodsSpecMapper.insertSpec(spec);
            count += InsertSpecRow;
        }else{//如果该商品规格存在
            //将查询到的商品规格的ID给传来的参数的商品规格ID
            spec.setId(mallGoodsSpec.getId());
        }

        //遍历所有要添加的规格选项
        for (MallGoodsSpecOptions option : spec.getOptions()) {
            if (StringUtils.isEmpty (option.getOptionName())) {
                continue;
            }
            //将添加商品规格的回填主键赋值规格选项
            option.setSpecId(spec.getId());
            //查询要添加的规格选项是是否存在
            MallGoodsSpecOptions mallGoodsSpecOptions = mallGoodsSpecOptionsMapper.findByNameAndSpecId(option);
            //如果要添加的规格选项不存在,则执行添加操作,否则跳过不添加
            if(mallGoodsSpecOptions == null){
                Integer row = mallGoodsSpecOptionsMapper.insertSpecOptions(option);
                count += row;
            }
        }

        InfoResult infoResult = new InfoResult();
        infoResult.setSuccess(true);
        infoResult.setMsg("添加"+count+"条记录成功");
        return infoResult;
    }

    /**
     * @Note : 修改商品规格选项
     * @Date : 2022-01-20 09:23:01
     * @Author : 清酒吖
    */
    @Override
    public InfoResult updateSpecOptions(MallGoodsSpecOptions options) {
        if(options == null){
            return new InfoResult(false,"参数错误","");
        }

        if(StringUtils.isEmpty(options.getOptionName())){
            return new InfoResult(false,"参数错误","");
        }

        //查询要添加的商品规格选项是否存在
        MallGoodsSpecOptions mallGoodsSpecOptions = mallGoodsSpecOptionsMapper.findByNameAndSpecId(options);

        //如果存在，则不修改,否则修改
        if(mallGoodsSpecOptions==null){
            Integer row = mallGoodsSpecOptionsMapper.updateSpecOptions(options);
            return new InfoResult(true,"修改成功!!!",row);
        }else{
            return new InfoResult(false, "该商品规格的规格选项已经存在！！！","");
        }
    }

    /**
     * @Note : 删除商品的规格选项以及规格
     * @Date : 2022-01-20 09:57:12
     * @Author : 清酒吖
    */
    @Override
    public InfoResult delSepcAndOptions(MallGoodsSpecOptions options) {
        // 如果传过来的参数为空，则返回错误信息
        if(options == null){
            return new InfoResult(false, "参数错误","");
        }
        //根据规格选项ID,删除该规格选项
        Integer delOptionsRow = mallGoodsSpecOptionsMapper.delOptions(options.getId());

        //执行操作数
        int count = 0;
        count = count + delOptionsRow;
        //返回的信息
        InfoResult infoResult = new InfoResult(true,"删除商品规格选项成功!!!",count);


        //查询该商品的规格选项的规格是否还存在有其他规格选项
        List<MallGoodsSpecOptions> optionsList = mallGoodsSpecOptionsMapper.findOptionsBySpecId(options.getSpecId());

        //根据该商品的规格查询是否还存在有规格选项
        Integer optionsCount = mallGoodsSpecOptionsMapper.selectOptionsBySpecId(options.getSpecId());

        //如果该商品规格不存在其他规格选项时,删除该商品规格
//        if(optionsList.size()<=0){
        if(optionsCount<=0){
            //删除商品规格
            Integer row = mallGoodsSpecMapper.delSpec(options.getSpecId());
            count += row;
            return new InfoResult(true, "删除商品规格选项成功,该商品规格无其他规格选项，删除商品规格成功!!!",count);
        }
        return infoResult;
    }

    /**
     * @Note : 查询所有商品规格
     * @Date : 2022-01-20 17:38:33
     * @Author : 清酒吖
    */ 
    @Override
    public InfoResult findSpecAll() {
        List<MallGoodsSpec> specList = mallGoodsSpecMapper.selectAll();
        return new InfoResult(true,"查询所有商品规格成功!!!",specList);
    }

    /**
     * @Note : 批量删除商品规格和规格选项
     * @Date : 2022-01-21 11:56:01
     * @Author : 清酒吖
    */
    @Override
    public InfoResult removeSpecAndOptions(SpecOptionsVO specOptionsVO) {
        if(specOptionsVO == null){
            return new InfoResult(false, "参数错误","");
        }
        if(specOptionsVO.getSpecId().size()<=0 || specOptionsVO.getOptionsId().size()<=0){
            return new InfoResult(false, "参数错误","");
        }

        // 批量删除商品规格选项
        Integer optionsRow = mallGoodsSpecOptionsMapper.delBatchOptions(specOptionsVO.getOptionsId());

        // 将产品规格ID数组先排序,后去重
        specOptionsVO.getSpecId().sort((a,b)->a.compareTo(b.intValue()));
        List<Integer> specIdList = specOptionsVO.getSpecId().stream().distinct().collect(Collectors.toList());

        // 根据产品规格ID进行分组查询商品规格选项总数
        List<Integer> countList = mallGoodsSpecOptionsMapper.findOptionsGroupBySpecId(specIdList);

        Map<Integer, Integer> map = specIdList.stream().collect(Collectors.toMap(key -> key, key -> countList.get(specIdList.indexOf(key))));

        // 将规格选项总数为0的规格选项的规格过滤出来
        map.entrySet().removeIf(m->m.getValue() != 0);
        // 将key值取出来放到数组中
        Set<Integer> set = map.keySet();
        ArrayList<Integer> result = new ArrayList<>(set);
        if(result.size()<=0){
            return new InfoResult(true, "删除了"+optionsRow+"条规格选项记录",optionsRow);
        }
        // 对规格进行批量删除
        Integer specRow = mallGoodsSpecMapper.delBatchSpecs(result);
        return new InfoResult(true, "删除了"+optionsRow+"条规格选项记录!!删除了"+specRow+"条规格记录!!!",new HashMap<Integer,Integer>(optionsRow,specRow));
    }

    /**
     * @Note : 根据商品模板id查询面板
     * @Date : 2022-02-04 15:49:04
     * @Author : 清酒吖
    */
    @Override
    public List<MallGoodsSpec> findSpecAndOptionsByTemplateId(String templateId) {
        if(StringUtils.isEmpty(templateId)){
            return new ArrayList<>();
        }
        // 根据商品模板查询商品模板信息
        MallGoodsTemplate template = mallGoodsTemplateMapper.findTemplateById(templateId);

        // 判断查询的模板是否为空
        if(template == null ){
            return new ArrayList<>();
        }

        // 获取商品规格面板([{"id":2,"specName":"颜色"},{"id":5,"specName":"包装"},{"id":14,"specName":"内存"}])
        String spec = template.getSpec();
        // 通过hutool工具包转化为List
        List<MallGoodsSpec> mallGoodsSpecList = JSONUtil.toList(spec, MallGoodsSpec.class);

        mallGoodsSpecList.forEach(item->{
            // 获取规格选项信息
            List<MallGoodsSpecOptions> optionsList
                    = mallGoodsSpecOptionsMapper.findOptionsBySpecId(item.getId());
            item.setOptions(optionsList);
        });

        return mallGoodsSpecList;
    }
}
